#include <iostream>
#include <signal.h>
#include <string>
#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/wait.h>
using namespace std;
// void Usrage(int signnum)
// {
//     cout<<"实现自定义的信号"<<endl;
//     // exit(0);
// }

// int main()
// {
//     signal(18,Usrage);
    
//     int cnt=20;
//     while(cnt--)
//     {
//         sleep(1);

//         // if(cnt%2==0) 
//         printf("I am a process, my PID %d\n",getpid());
//     }

//     return 0;
// }
// int main()
// {
//     for(int i=1;i<=31;i++)
//     {
//         signal(i,Usrage);
//     }

//     while(1)
//     {
//         cout<<"我是一个proc 我的PID"<< getpid()<<endl;
//         sleep(1);
//     }
//     return 0;
// }

// int main(int argc,char* argv[])//参数是一个数组指针
// {
//     if(argc!=3)
//     {
//         cout<<"errno"<<endl;
//         return 1;
//     }    
    
//     int sign=stoi(argv[1]);
//     int pid=stoi(argv[2]);

//     kill(pid,sign);
//     return 0;
// }

// int main()
// {

//     signal(6,Usrage);

//     int n=1;
//     while(n>0)
//     {
//         cout<<"运行了 "<<n<<endl;
//         sleep(1);
//         n++;
//     //    if(n>5) raise(2);
//        if(n>5) abort();
//     }
//     return 0;
// }

// void test(int sign)
// {
//     cout<<"收到了14 信号"<<endl;

//     int n=alarm(5);//返回距离是一个闹钟的时差

//     cout<< "时间差是 n="<<n<<endl;
// }

// int main()
// {
//     alarm(10);
//     signal(14,test);
//     while(1)
//     {
//         cout<<"myprocess run "<<getpid()<<endl;
//         sleep(1);
//     }

//     return 0;
// }
// void test(int sign)
// {
//     cout<<"i not 管理"<<endl;
//     sleep(1);
// }

// int main()
// {
//     // signal(8,test);
//     int a=10;
//     a/=0;
//     return 0;
// }

// int main()
// {

//     signal(11,test);
//     int *p=nullptr;
//     *p=10;
//     //不解决 越界写问题，每一次轮询执行，操作系统都发11号信号，但是并不处理，所以一直死循环了
//     return 0;
// }
// int main()
// {

//     // signal(11,test);
//     int *p=nullptr;
//     *p=10;
//     //不解决 越界写问题，每一次轮询执行，操作系统都发11号信号，但是并不处理，所以一直死循环了
//     return 0;
// }
// #include <stdlib.h>

// int main() {
//     pid_t pid = fork();  // 创建子进程

//     if (pid == 0) {
//         // 子进程
//         std::cout << "子进程正在运行..." << std::endl;
//         exit(0);  // 子进程正常退出，返回状态 0
//     } else if (pid > 0) {
//         // 父进程
//         int status;
//         waitpid(pid, &status, 0);  // 父进程等待子进程退出

//         // if (WIFEXITED(status)) {
//         //     std::cout << "子进程正常退出，退出状态：" << WEXITSTATUS(status) << std::endl;
//         // }
//         cout<<(status&0x7F)<<endl;
//     }

//     return 0;
// }

// void test(int signo)
// {
//     cout<<"我是2号信号，我被阻塞了"<<endl;
// }

// void PrintPending(sigset_t pend)
// {
//     for(int i=1;i<=31;i++)
//     {
//         int n=sigismember(&pend,i);
//         if(n==1) cout<<"1";
//         else cout<<"0";
//     }
//     cout<<"\n\n";
// }

// int main()
// {
//     signal(2,test);

//     sigset_t bset,oset;
//     sigemptyset(&bset);
//     sigemptyset(&oset);
    
//     sigaddset(&bset,2);

//     sigprocmask(SIG_SETMASK,&bset,&oset);

//     sigset_t pending;
//     int cnt=0;
//     while(1)
//     {
//         int n=sigpending(&pending);
//         if(n<0) continue;

//         PrintPending(pending);

//         sleep(1);
//         cnt++;

//         if(cnt==15)
//         {
//             cout<<"unblock 2 signo"<<endl;
//             sigprocmask(SIG_SETMASK,&oset,nullptr);
//         }
//     }
//     return 0;
// }


// volatile int flag = 0;

// void handler(int signo)
// {
//     cout << "catch a signal: " << signo << endl;
//     flag = 1;
// }

// int main()
// {
//     signal(2, handler);
//     // 在优化条件下， flag变量可能被直接优化到CPU内的寄存器中
//     while(!flag); // flag 0, !falg 真

//     cout << "process quit normal" << endl;
//     return 0;
// }


//sigaction 执行捕捉过程会，屏蔽你想屏蔽的信号 //
//指的是信号在运行中，把设置的信号屏蔽，当信号执行完之后，屏蔽也就没有效果了

// #include <string.h>

// void PrintPend(sigset_t pend)
// {
//     for(int i=1;i<=31;i++)
//     {
//         if(sigismember(&pend,i))
//         cout<<"1";
//         else cout<<"0";
//     }
//     cout<<"   "<<getpid()<<"\n\n";
// }

// void handle (int signo)
// {
//      cout<<"我被捕捉了，我是2号信号"<<endl;
//     int cnt=10;
//     while(cnt--)
//     {
//         sigset_t pend;
//         sigisemptyset(&pend);

//         int n=sigpending(&pend);

//         // if(n>0) 
//         PrintPend(pend);
        
//         sleep(1);
//     }
//     // eixt(0);
// }


// int main()
// {
//     struct sigaction oset,bset;

//     memset(&oset,0,sizeof(oset));
//     memset(&bset,0,sizeof(bset));
    
//     bset.sa_handler=handle;

//     sigaddset(&bset.sa_mask,5);
//     sigaddset(&bset.sa_mask,3);
//     sigaddset(&bset.sa_mask,4);

//     sigaction(2,&bset,&oset);
    

//     while(1);
//     // while(1)
//     // {
//     //     sleep(1);
//     //     // PrintPend(bset.sa_mask);//在此处获得的其实是bset的阻塞表，而不是当前进程的pending表
//     //     sigset_t pend;
//     //     sigemptyset(&pend);

//     //     PrintPend(pend);
//     // }
//     return 0;
// }

// volatile int flag=0;//防止编译器过度优化.

// void handle(int signo)
// {
//     cout<<"捕捉2 号信号"<<endl;
//     flag=1;
// }

// int main()
// {
//     signal(2,handle);
//     while(!flag);
//     return 0;
// }

void handler(int signo)
{
    printf("进程 %d 捕捉到了 %d 号信号\n", getpid(), signo);
}

int main()
{
    signal(SIGCHLD, handler);

    pid_t id = fork();
    if(id == 0)
    {
        int n = 5;
        while(n)
            printf("子进程剩余生存时间: %d秒 [pid: %d  ppid: %d]\n", n--, getpid(), getppid());
        
        // 子进程退出
        exit(-1);
    }

    waitpid(id, NULL, 0);
    return 0;
}
